home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / Xprof / xmeasure / tstcolor.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  10KB  |  479 lines
  1. /*==================================================================
  2.  *      File :          tstcolor.c
  3.  *      Package:        Xmeasure
  4.  * 
  5.  *      Author :        Aloke Gupta.
  6.  *
  7.  *  (C) Copyright 1992, Aloke Gupta.
  8.  *  All rights granted to University of Illinois Board of Regents.
  9.  *==================================================================*/
  10.  
  11. #include "perf.h"
  12.  
  13. #define MAX_PLANES 1
  14. #define NUMCOLORS  8
  15.  
  16. /* Shared variables */
  17. static XColor        xcolors[NUMCOLORS];
  18. static unsigned int  *plane_masks;
  19. static unsigned int  pmask;
  20. static unsigned long *pixels;
  21. static char          *cname = "red";
  22.  
  23. static Colormap      *colormaps;
  24. static Colormap      **cmaplist;    /* array of pointers to Colormap */
  25. static int           i;
  26.  
  27. /* ====================================================================== */
  28.  
  29. int   CreateColormap(xd, xp) 
  30. XD *xd;
  31. XParams *xp;
  32. {
  33.     for (i = 0; i < xp->itns; i++) {
  34.       colormaps[i] = XCreateColormap(xd->display, xd->window,
  35.                       xd->visual, AllocNone);
  36.       if (!colormaps[i]) {
  37.     xp->itns = i;
  38.     fprintf(stderr,"# CreateColormap: Can only create %d colormaps out of %d\n",
  39.             i , xp->itns);
  40.     return;
  41.       }
  42.     }
  43. }
  44.  
  45. int i_CreateColormap(xd, xp) 
  46. XD *xd;
  47. XParams *xp;
  48. { colormaps = (Colormap *) calloc (xp->itns, sizeof (Colormap)); }
  49.  
  50. int c_CreateColormap(xd, xp) 
  51. XD *xd;
  52. XParams *xp;
  53. {
  54.     for (i = 0; i < xp->itns; i++)
  55.     XFreeColormap(xd->display, colormaps[i]);
  56.     free(colormaps);
  57. }
  58.  
  59. /* ====================================================================== */
  60.  
  61. int   FreeColormap(xd, xp)   
  62. XD *xd;
  63. XParams *xp;
  64. {
  65.     for (i = 0; i < xp->itns; i++)
  66.     XFreeColormap(xd->display, colormaps[i]);
  67. }
  68.  
  69. int i_FreeColormap(xd, xp)   
  70. XD *xd;
  71. XParams *xp;
  72. {
  73.     colormaps = (Colormap *)  calloc (xp->itns, sizeof (Colormap));
  74.  
  75.     for (i = 0; i < xp->itns; i++) {
  76.       colormaps[i] = XCreateColormap(xd->display, xd->window,
  77.                                       xd->visual, AllocNone);
  78.       if (!colormaps[i]) {
  79.         xp->itns = i;
  80.         fprintf(stderr,"# FreeColormap: Can only create %d colormaps out of %d\n",
  81.                         i , xp->itns);
  82.         return;
  83.       }
  84.     }
  85. }
  86.  
  87. int c_FreeColormap(xd, xp)   
  88. XD *xd;
  89. XParams *xp;
  90. { free(colormaps); }
  91.  
  92. /* ====================================================================== */
  93.  
  94. int   CopyColormapAndFree(xd, xp)
  95. XD *xd;
  96. XParams *xp;
  97. {
  98.     for (i = 0; i < xp->itns; i++) {
  99.       colormaps[i] = XCopyColormapAndFree(xd->display, xd->cmap);
  100.       if (!colormaps[i]) {
  101.         xp->itns = i;
  102.         fprintf(stderr,"# CopyColormapAndFree: Can only create %d colormaps out of %d\n",
  103.                         i , xp->itns);
  104.         return;
  105.       }
  106.     }
  107. }
  108.  
  109. int i_CopyColormapAndFree(xd, xp)
  110. XD *xd;
  111. XParams *xp;
  112. { colormaps = (Colormap *) calloc (xp->itns, sizeof (Colormap)); }
  113.  
  114. int c_CopyColormapAndFree(xd, xp)
  115. XD *xd;
  116. XParams *xp;
  117. {
  118.     for (i = 0; i < xp->itns; i++)
  119.         XFreeColormap(xd->display, colormaps[i]);
  120.     free(colormaps);
  121. }
  122.  
  123. /* ====================================================================== */
  124.  
  125. int   InstallColormap(xd, xp)
  126. XD *xd;
  127. XParams *xp;
  128. {
  129.     for (i = 0; i < xp->itns; i++) {
  130.     if (!XInstallColormap(xd->display, xd->cmap)) {
  131.         fprintf(stderr, "# InstallColormap: Cannot install %dth colormap\n",
  132.                 i);
  133.         xp->itns=i;
  134.         return ;
  135.     }
  136.     }
  137. }
  138.  
  139. int i_InstallColormap(xd, xp)
  140. XD *xd;
  141. XParams *xp;
  142. { }
  143.  
  144. int c_InstallColormap(xd, xp)
  145. XD *xd;
  146. XParams *xp;
  147. { }
  148.  
  149. /* ====================================================================== */
  150.  
  151. int   UninstallColormap(xd, xp)
  152. XD *xd;
  153. XParams *xp;
  154. {
  155.     for (i = 0; i < xp->itns; i++)
  156.     XUninstallColormap(xd->display, xd->cmap);
  157. }
  158.  
  159. int i_UninstallColormap(xd, xp)
  160. XD *xd;
  161. XParams *xp;
  162. { }
  163.  
  164. int c_UninstallColormap(xd, xp)
  165. XD *xd;
  166. XParams *xp;
  167. { }
  168.  
  169. /* ====================================================================== */
  170.  
  171. int   ListInstalledColormaps(xd, xp)
  172. XD *xd;
  173. XParams *xp;
  174. {
  175.     int num;
  176.  
  177.     for (i = 0; i < xp->itns; i++) 
  178.     cmaplist[i] = XListInstalledColormaps(xd->display, xd->window, &num);
  179. }
  180.  
  181. int i_ListInstalledColormaps(xd, xp)
  182. XD *xd;
  183. XParams *xp;
  184. { 
  185.     cmaplist = (Colormap **) calloc (xp->itns, sizeof (Colormap *));
  186. }
  187.  
  188. int c_ListInstalledColormaps(xd, xp)
  189. XD *xd;
  190. XParams *xp;
  191. {
  192.     for (i = 0; i < xp->itns; i++)
  193.     XFree((caddr_t) cmaplist[i]);
  194.     free(cmaplist);
  195. }
  196.  
  197. /* ====================================================================== */
  198.  
  199. int   AllocColor(xd, xp)     
  200. XD *xd;
  201. XParams *xp;
  202. {
  203.     for (i = 0; i < xp->itns; i++){
  204.     if (!XAllocColor(xd->display, xd->cmap, &xcolors[0])) {
  205.         fprintf(stderr,"# AllocColor: Cannot allocate %dth color\n", i);
  206.     }
  207.     }
  208. }
  209.  
  210. int i_AllocColor(xd, xp)     
  211. XD *xd;
  212. XParams *xp;
  213. { 
  214.     XParseColor(xd->display, xd->cmap, cname, &xcolors[0]);
  215. }
  216.  
  217. int c_AllocColor(xd, xp)     
  218. XD *xd;
  219. XParams *xp;
  220. { }
  221.  
  222. /* ====================================================================== */
  223.  
  224. int   AllocNamedColor(xd, xp)
  225. XD *xd;
  226. XParams *xp;
  227. {
  228.     for (i = 0; i < xp->itns; i++) {
  229.     if (!XAllocNamedColor(xd->display,xd->cmap,cname,&xcolors[0],&xcolors[1]))
  230.         fprintf(stderr,"#AllocNamedColor: Cannot allocate %dth color\n",i);
  231.     }
  232. }
  233.  
  234. int i_AllocNamedColor(xd, xp)
  235. XD *xd;
  236. XParams *xp;
  237. { }
  238.  
  239. int c_AllocNamedColor(xd, xp)
  240. XD *xd;
  241. XParams *xp;
  242. { }
  243.  
  244. /* ====================================================================== */
  245.  
  246. int   AllocColorCells(xd, xp)
  247. XD *xd;
  248. XParams *xp;
  249. {
  250.  
  251.     for (i = 0; i < xp->itns; i++) {
  252.     if (!XAllocColorCells(xd->display, xd->cmap, False,  
  253.         plane_masks + (i * MAX_PLANES), MAX_PLANES,
  254.         pixels      + (i * NUMCOLORS ), NUMCOLORS)) {
  255.     /*
  256.         fprintf(stderr,
  257.            "\n# AllocColorCells: Cannot allocate %d cells for the %d itn\n",
  258.             NUMCOLORS, i);
  259.         fflush(stderr);
  260.     */
  261.         xp->itns = i;
  262.         return;
  263.     }
  264.     }
  265. }
  266.  
  267. int i_AllocColorCells(xd, xp)
  268. XD *xd;
  269. XParams *xp;
  270. { 
  271.     plane_masks = (unsigned *)      calloc(MAX_PLANES * xp->itns,
  272.                         sizeof(unsigned));
  273.     pixels    = (unsigned long *) calloc(NUMCOLORS * xp->itns,
  274.                         sizeof(unsigned long));
  275. }
  276.  
  277. int c_AllocColorCells(xd, xp)
  278. XD *xd;
  279. XParams *xp;
  280. { 
  281.     pmask=0;
  282.     if (xp->itns > 0)
  283.       for (i=0; i <MAX_PLANES; i++)
  284.     pmask |= plane_masks[i];
  285.     for (i = 0; i < xp->itns; i++) {
  286.     XFreeColors(xd->display, xd->cmap, 
  287.         pixels      + (i * NUMCOLORS), NUMCOLORS,
  288.         pmask);
  289.     }
  290.     free(plane_masks);
  291.     free(pixels);
  292. }
  293.  
  294. /* ====================================================================== */
  295.  
  296. int   AllocColorPlanes(xd, xp)
  297. XD *xd;
  298. XParams *xp;
  299. {
  300. }
  301.  
  302. int i_AllocColorPlanes(xd, xp)
  303. XD *xd;
  304. XParams *xp;
  305. {
  306. }
  307.  
  308. int c_AllocColorPlanes(xd, xp)
  309. XD *xd;
  310. XParams *xp;
  311. {
  312. }
  313.  
  314. /* ====================================================================== */
  315.  
  316. int   FreeColors(xd, xp)     
  317. XD *xd;
  318. XParams *xp;
  319. {
  320.     for (i = 0; i < xp->itns; i++) 
  321.         XFreeColors(xd->display,xd->cmap,pixels+(i*NUMCOLORS),NUMCOLORS,pmask);
  322. }
  323.  
  324. int i_FreeColors(xd, xp)     
  325. XD *xd;
  326. XParams *xp;
  327. {
  328.     plane_masks = (unsigned *)     calloc(MAX_PLANES*xp->itns,sizeof(unsigned));
  329.     pixels    = (unsigned long *) calloc(NUMCOLORS*xp->itns,sizeof(unsigned));
  330.  
  331.     for (i = 0; i < xp->itns; i++) {
  332.         if (!XAllocColorCells(xd->display, xd->cmap, False,
  333.                 plane_masks + (i * MAX_PLANES), MAX_PLANES,
  334.                 pixels      + (i * NUMCOLORS ), NUMCOLORS)) {
  335.             xp->itns = i;
  336.             return;
  337.         }
  338.     }
  339.     pmask=0;
  340.     for (i=0; i <MAX_PLANES; i++)
  341.         pmask |= plane_masks[i];
  342. }
  343.  
  344. int c_FreeColors(xd, xp)     
  345. XD *xd;
  346. XParams *xp;
  347. {
  348.     free(plane_masks);
  349.     free(pixels);
  350. }
  351.  
  352. /* ====================================================================== */
  353.  
  354. int   StoreColors(xd, xp)    
  355. XD *xd;
  356. XParams *xp;
  357. {
  358.     for (i = 0; i < xp->itns; i++)
  359.     XStoreColors(xd->display, xd->cmap, xcolors, NUMCOLORS);
  360. }
  361.  
  362. int i_StoreColors(xd, xp)    
  363. XD *xd;
  364. XParams *xp;
  365. { 
  366.     plane_masks = (unsigned *)      calloc(MAX_PLANES, sizeof(unsigned));
  367.     pixels    = (unsigned long *) calloc(NUMCOLORS,  sizeof(unsigned));
  368.  
  369.     if (!XAllocColorCells(xd->display, xd->cmap, False,  plane_masks,
  370.                 MAX_PLANES, pixels, NUMCOLORS)) {
  371.     fprintf(stderr,"\n# StoreColors: Cannot allocate %d cells to test\n",
  372.                 NUMCOLORS); fflush(stderr);
  373.     xp->itns = 0;
  374.     return;
  375.     }
  376.     for (i = 0; i < NUMCOLORS; i++) {
  377.     XParseColor(xd->display, xd->cmap, cname, &xcolors[i]);
  378.     xcolors[i].pixel = pixels[i];
  379.     }
  380. }
  381.  
  382. int c_StoreColors(xd, xp)    
  383. XD *xd;
  384. XParams *xp;
  385. {
  386.     pmask=0;
  387.     for (i=0; i < MAX_PLANES; i++)
  388.     pmask |= plane_masks[i];
  389.     if (xp->itns !=0)
  390.     XFreeColors(xd->display, xd->cmap, pixels, NUMCOLORS, pmask);
  391.     free(plane_masks);
  392.     free(pixels);
  393. }
  394.  
  395. /* ====================================================================== */
  396.  
  397. int   StoreNamedColor(xd, xp)
  398. XD *xd;
  399. XParams *xp;
  400. {
  401.     for (i = 0; i < xp->itns; i++)
  402.         XStoreNamedColor(xd->display, xd->cmap, cname,
  403.                 pixels[0], DoRed | DoGreen| DoBlue);
  404. }
  405.  
  406. int i_StoreNamedColor(xd, xp)
  407. XD *xd;
  408. XParams *xp;
  409. {
  410.     plane_masks = (unsigned *)      calloc(MAX_PLANES, sizeof(unsigned));
  411.     pixels    = (unsigned long *) calloc(NUMCOLORS , sizeof(unsigned));
  412.  
  413.     if (!XAllocColorCells(xd->display, xd->cmap, False,  plane_masks,
  414.                             MAX_PLANES, pixels, 1)) {
  415.         fprintf(stderr,"\n# StoreNamedColor: Cannot allocate 1 cell to test\n");
  416.     fflush(stderr);
  417.         xp->itns = 0;
  418.         return;
  419.     }
  420. }
  421.  
  422. int c_StoreNamedColor(xd, xp)
  423. XD *xd;
  424. XParams *xp;
  425. {
  426.     pmask=0;
  427.     for (i=0; i < MAX_PLANES; i++)
  428.         pmask |= plane_masks[i];
  429.     if (xp->itns !=0)
  430.     XFreeColors(xd->display, xd->cmap, pixels, 1, pmask);
  431.     free(plane_masks);
  432.     free(pixels);
  433. }
  434.  
  435. /* ====================================================================== */
  436.  
  437. int   QueryColors(xd, xp)    
  438. XD *xd;
  439. XParams *xp;
  440. {
  441.     for (i = 0; i < xp->itns; i++)
  442.     XQueryColors(xd->display, xd->cmap, xcolors, NUMCOLORS);
  443. }
  444.  
  445. int i_QueryColors(xd, xp)    
  446. XD *xd;
  447. XParams *xp;
  448. {
  449.     for (i = 0; i < NUMCOLORS; i++)
  450.     xcolors[i].pixel = BlackPixel(xd->display, xd->screen);
  451. }
  452.  
  453. int c_QueryColors(xd, xp)    
  454. XD *xd;
  455. XParams *xp;
  456. { }
  457.  
  458. /* ====================================================================== */
  459.  
  460. int   LookupColor(xd, xp)    
  461. XD *xd;
  462. XParams *xp;
  463. {
  464.     for (i = 0; i < xp->itns; i++)
  465.     XLookupColor(xd->display, xd->cmap, cname, &xcolors[0], &xcolors[1]);
  466. }
  467.  
  468. int i_LookupColor(xd, xp)    
  469. XD *xd;
  470. XParams *xp;
  471. { }
  472.  
  473. int c_LookupColor(xd, xp)    
  474. XD *xd;
  475. XParams *xp;
  476. { }
  477.  
  478. /* ====================================================================== */
  479.